home *** CD-ROM | disk | FTP | other *** search
/ FishMarket 1.0 / FishMarket v1.0.iso / fishies / 326-350 / disk_331 / csh / src / comm3.c < prev    next >
C/C++ Source or Header  |  1992-05-06  |  12KB  |  689 lines
  1. /*
  2.  * COMM3.C
  3.  *
  4.  * Version 4.01A by Carlo Borreo & Cesare Dieni 17-Feb-90
  5.  *
  6.  */
  7.  
  8. do_assign() {
  9. switch(ac) {
  10.     case 1:  assignlist();
  11.          break;
  12.     case 2:  doassign(av[1], NULL);
  13.          break;
  14.     case 3:  doassign(av[1], av[2]);
  15.          break;
  16.     default: ierror(NULL, 500);
  17.          break;
  18.     }
  19. return 0;
  20. }
  21.  
  22. char *assign_errors[4]={
  23.     "",
  24.     "Name %s is not valid\n",
  25.     "Weird error\n",
  26.     "Can't cancel %s\n"
  27.     };
  28.  
  29. doassign(log, phy)
  30. char *log, *phy;
  31. {
  32. int last=strlen(log) - 1;
  33.  
  34. if (log[last] != ':') fprintf(stderr, "Bad name %s\n", log);
  35. else {
  36.     log[last] = 0;
  37.     fprintf(stderr,assign_errors[Assign(log, phy)],phy);
  38.     }
  39. }
  40.  
  41. assignlist()
  42. {
  43. struct DirectoryEntry *de_head=NULL, *de;
  44. char buf[256];
  45. BPTR lock;
  46. int ctr=0;
  47.  
  48. AddDADevs(&de_head, DLF_DEVICES | DLF_VOLUMES | DLF_DIRS);
  49. printf("Devices:\n");
  50. for (de=de_head; de && de->de_Type==DLX_DEVICE; de=de->de_Next) {
  51.     printf("%-8s",de->de_Name);
  52.     if (ctr++ == 5) { ctr=0; printf("\n"); }
  53.     }
  54. printf("\n\nVolumes:\n");
  55. for (    ;
  56.     de && (de->de_Type==DLX_VOLUME || de->de_Type==DLX_UNMOUNTED);
  57.     de=de->de_Next
  58.     )
  59.     printf( "%-16s %s\n",
  60.         de->de_Name,
  61.         de->de_Type == DLX_VOLUME ? "[Mounted]" : ""
  62.         );
  63. printf("\nDirectories:\n");
  64. for (; de && de->de_Type==DLX_ASSIGN; de=de->de_Next) {
  65.     if (lock=Lock(de->de_Name, ACCESS_READ)) {
  66.         PathName(lock, buf, 256L);
  67.         UnLock(lock);
  68.         }
  69.     else
  70.         strcpy(buf,"Unexisting lock");
  71.     printf("%-20s%s\n",de->de_Name,buf);
  72.     }
  73. FreeDAList(&de_head);
  74. }
  75.  
  76. do_join()
  77. {
  78. BPTR sou, dest;
  79. char *buffer;
  80. unsigned int i;
  81. long n;
  82. char *namedest=av[--ac];
  83.  
  84. get_opt("r", &i);
  85. if (options==0 && exists(namedest)) { ierror(namedest,203); return 20; }
  86. if ( (buffer=malloc(8192)) == NULL ) { ierror(NULL,103); return 20; }
  87. if ( (dest=Open(namedest, MODE_NEWFILE)) == NULL )
  88.     { pError(namedest); goto fail1; }
  89. for (i=1; i<ac; i++) {
  90.     if ( (sou=Open(av[i], MODE_OLDFILE)) == NULL ) pError(av[i]);
  91.     else
  92.         while( (n=Read(sou, buffer, 8192L)) > 0 )
  93.             if (Write(dest, buffer, n) != n)
  94.                 { pError(namedest); Close(sou); goto fail2; }
  95.     Close(sou);
  96.     }
  97. fail2:
  98.     Close(dest);
  99. fail1:
  100.     free(buffer);
  101.     return 0;
  102. }
  103.  
  104. #define BUFDIM 512L
  105. #define MAXSTR 256
  106.  
  107. int minstr;
  108.  
  109. strings_in_file(s)
  110. char *s;
  111. {
  112. char c;
  113. char readbuf[BUFDIM+1], strbuf[MAXSTR+1];
  114. register unsigned int i, strctr=0;
  115. BPTR fh;
  116. int out, n;
  117.  
  118. if ( fh=Open(s, MODE_OLDFILE) ) {
  119.     fprintf(stderr, "Strings in %s (len>=%d):\n",s,minstr);
  120.     while ( (n=(int)Read(fh, readbuf, BUFDIM)) > 0 && !CHECKBREAK() )
  121.         for (i=0; i<n; i++) {
  122.         c=readbuf[i];
  123.         if (c<0x20 || c>0x7f) {
  124.             out=(strctr>=minstr);
  125.             if (!out) strctr=0;
  126.             }
  127.         else {
  128.             strbuf[strctr++]=c;
  129.             out=(strctr>=BUFDIM);
  130.             }
  131.         if (out) {
  132.             strbuf[strctr]='\0';
  133.             puts(strbuf);
  134.             strctr=0;
  135.             }
  136.         }
  137.     Close(fh);
  138.     }
  139. else pError(s);
  140. }
  141.  
  142. do_strings()
  143. {
  144. minstr=myatoi(av[--ac],1,255);
  145. all_args("r", strings_in_file, 0);
  146. return 0;
  147. }
  148.  
  149. BPTR myfile[MAXMYFILES];
  150.  
  151. do_open()
  152. {
  153. long mode;
  154. unsigned int n;
  155.  
  156. switch (toupper(av[2][0])) {
  157.     case 'R': mode=MODE_OLDFILE; break;
  158.     case 'W': mode=MODE_NEWFILE; break;
  159.     default : ierror(NULL,500); return;
  160.     }
  161. n=(unsigned int)myatoi(av[3],0,MAXMYFILES-1); if (atoierr) return 20;
  162. if (myfile[n]) myclose(n);
  163. myfile[n]=Open(av[1],mode);
  164. return (myfile[n]==NULL);
  165. }
  166.  
  167. do_close()
  168. {
  169. register unsigned int i;
  170. int n;
  171.  
  172. if (ac==1)
  173.     for (i=1; i<MAXMYFILES; i++)
  174.         myclose(i);
  175. for (i=1; i<ac; i++) {
  176.     n=myatoi(av[i],0,MAXMYFILES-1); if (atoierr) return 20;
  177.     myclose(n);
  178.     }
  179. return 0;
  180. }
  181.  
  182. myclose(n)
  183. {
  184. if (myfile[n]) { Close(myfile[n]); myfile[n]=NULL; }
  185. }
  186.  
  187. do_fileslist()
  188. {
  189. register unsigned short i;
  190. int flag=0;
  191.  
  192. printf("Open files:");
  193. for (i=0; i<MAXMYFILES; i++)
  194.     if (myfile[i]) { printf(" %d",i); flag=1; }
  195. if (!flag) printf(" None!");
  196. printf("\n");
  197. return 0;
  198. }
  199.  
  200. BPTR extOpen(name,mode)
  201. char *name;
  202. long mode;
  203. {
  204. if (name[0]=='.') return myfile[atoi(name+1)];
  205. return Open(name,mode);
  206. }
  207.  
  208. extClose(fh)
  209. BPTR fh;
  210. {
  211. register unsigned short i;
  212.  
  213. for (i=0; i<MAXMYFILES; i++)
  214.     if (myfile[i]==fh) return;
  215. Close(fh);
  216. }
  217.  
  218. do_basename()
  219. {
  220. set_var(LEVEL_SET, av[1], BaseName(av[2]));
  221. return 0;
  222. }
  223.  
  224. do_tackon()
  225. {
  226. char buf[256];
  227.  
  228. strcpy(buf, av[2]);
  229. TackOn(buf, av[3]);
  230. set_var(LEVEL_SET, av[1], buf);
  231. return 0;
  232. }
  233.  
  234. do_resident()
  235. {
  236. unsigned int i;
  237. register struct ResidentProgramNode *p;
  238. char buf[256];
  239.  
  240. get_opt("ard", &i);
  241. if (options==0 && ac>1) options=1;
  242. switch (options) {
  243.     case 0:
  244.     ObtainSemaphore (& (ArpBase->ResPrgProtection) );
  245.     if (p=ArpBase->ResidentPrgList) {
  246.         printf("Name             Users Access\n");
  247.         for (; p; p=p->rpn_Next)
  248.             printf("%-17s%5d%6d\n",
  249.                 p->rpn_Name, p->rpn_Usage, p->rpn_AccessCnt);
  250.         }
  251.     else printf("No resident program(s)\n");
  252.     ReleaseSemaphore(& (ArpBase->ResPrgProtection) );
  253.     break;
  254.     case 1:
  255.     for (; i<ac; i++)
  256.         if (loadres(av[i]))
  257.             printf("OK! %s is now resident\n", BaseName(av[i]));
  258.         else pError(av[i]);
  259.     break;
  260.     case 2:
  261.     for (; i<ac; i++)
  262.         if (RemResidentPrg(av[i])) ierror(av[i],202);
  263.         else printf("Removed %s\n",av[i]);
  264.     break;
  265.     case 4:
  266.     for (; i<ac; i++) {
  267.         sprintf(buf,"res_%s",av[i]);
  268.         Setenv(buf,"1");
  269.         }
  270.     break;
  271.     default:
  272.     ierror(NULL,500);
  273.     break;
  274.     }
  275. return 0;
  276. }
  277.  
  278. int loadres(s)
  279. char *s;
  280. {
  281. BPTR seg;
  282.  
  283. if (seg=(BPTR)LoadPrg(s)) AddResidentPrg(seg,BaseName(s));
  284. return (seg != NULL);
  285. }
  286.  
  287. struct ProcessControlBlock pcb={
  288.     4000,        /* pcb_StackSize    */
  289.     0,        /* pcb_Pri        */
  290.     };
  291. /* remaining field are NULL */
  292.     
  293. do_truerun(avline, backflag)
  294. char *avline;
  295. {
  296. char name[200];
  297. char *FindIt();
  298.  
  299. if (backflag) {
  300.     pcb.pcb_Control=NULL;
  301.     pcb.pcb_Input=pcb.pcb_Output=Open("NIL:",MODE_OLDFILE);
  302.     }
  303. else {
  304.     pcb.pcb_Control=NULL;
  305.     pcb.pcb_Input=pcb.pcb_Output =NULL;
  306.     }
  307. if (FindIt(av[1], "", name))
  308.     ASyncRun(name,next_word(next_word(avline)),&pcb);
  309. else
  310.     ierror(av[1],205);
  311. return 0;
  312. }
  313.  
  314. int exists(name)
  315. char *name;
  316. {
  317. BPTR lock;
  318.  
  319. if (lock=Lock(name,ACCESS_READ)) {
  320.     UnLock(lock);
  321.     return 1;
  322.     }
  323. return 0;
  324. }
  325.  
  326. do_aset()
  327. {
  328. Setenv(av[1],av[2]);
  329. return 0;
  330. }
  331.  
  332. #define HTYPELINE 16L
  333.  
  334. htype_a_file(s)
  335. char *s;
  336. {
  337. BPTR fh;
  338. long n, filesize=0;
  339. char buf[HTYPELINE+1];
  340. register unsigned short i;
  341.  
  342. if ( (fh=Open(s,MODE_OLDFILE))==NULL ) { pError(s); return 20; }
  343. while ( (n=Read(fh,buf,HTYPELINE))>0 && !dobreak()) {
  344.     printf("%06lx: ",filesize);
  345.     filesize+=n;
  346.     for (i=0; i<n; i++) {
  347.         printf( (i&3) ? "%02x" : " %02x",(int)(unsigned char)buf[i]);
  348.         if (buf[i]<0x20) buf[i]='.';
  349.         }
  350.     for ( ; i<HTYPELINE; i++) {
  351.         printf( (i&3) ? "  " : "   ");
  352.         buf[i]=' ';
  353.         }
  354.     buf[i]=0;
  355.     printf("    %s\n",buf);
  356.     }
  357. Close(fh);
  358. return 0;
  359. }
  360.  
  361. do_htype()
  362. {
  363. all_args("", htype_a_file, 0);
  364. return 0;
  365. }
  366.  
  367. do_stack()
  368. {
  369. long n;
  370.  
  371. if (ac>1) {
  372.     n=Atol(av[1]);
  373.     if (!IoErr()) Mycli->cli_DefaultStack=(long)(n >> 2L);
  374.     }
  375. else printf("current stack size is %ld bytes\n",
  376.                 (long)Mycli->cli_DefaultStack << 2L);
  377. return 0;
  378. }
  379.  
  380. do_fault()
  381. {
  382. struct PERROR *p;
  383. register unsigned int i;
  384. int n;
  385.  
  386. for (i=1; i<ac; i++) {
  387.     n=myatoi(av[i],0,32767);
  388.     if (!atoierr) {
  389.         for (p=Perror; p->errnum && p->errnum!=n; p++);
  390.         if (p->errnum)
  391.             printf("Fault %d: %s\n",n,p->errstr);
  392.         else
  393.             printf("Fault %d not recognized\n",n);
  394.         }
  395.     }
  396. return 0;
  397. }
  398.  
  399. struct rpncommand {
  400.     char *str;
  401.     int parsin, parsout;
  402.     };
  403.  
  404. struct rpncommand rpn[]={
  405.     "+",    2,    1,
  406.     "-",    2,    1,
  407.     "*",    2,    1,
  408.     "/",    2,    1,
  409.     "%",    2,    1,
  410.     "&",    2,    1,
  411.     "|",    2,    1,
  412.     "~",    1,    1,
  413.     ">",    2,    1,
  414.     "<",    2,    1,
  415.     "==",    2,    1,
  416.     "!",    1,    1,
  417.     "DUP",    1,    2,
  418.     "DROP",    1,    0,
  419.     "SWAP",    2,    2,
  420.     "HELP",    0,    0,
  421.     NULL,    0,    1,    /* this looks for a number */
  422. };
  423.  
  424. do_rpn(garbage,ifflag) /* ifflag!=0 if called from if */
  425. char *garbage;
  426. {
  427. register long n0, n1;
  428. long t;
  429. unsigned int i, j;
  430. int sp=0;
  431. long stack[100];
  432. struct rpncommand *temp;
  433.  
  434. i=1;
  435. if (ifflag) get_opt("rn",&i);
  436. for (; i<ac; i++) {
  437.     for (j=0; rpn[j].str && Strcmp(rpn[j].str,av[i]); j++) ;
  438.     n0=stack[sp-1];
  439.     n1=stack[sp-2];
  440.     sp -= (rpn[j].parsin);
  441.     if (sp<0) { fprintf(stderr, "RPN: Empty stack\n"); return 1; }
  442.     switch (j) {
  443.       case 0:    n0 += n1;        break;
  444.       case 1:    n0 = n1-n0;        break;
  445.       case 2:    n0 *= n1;        break;
  446.       case 3:    n0 = n1/n0;        break;
  447.       case 4:    n0 = n1%n0;        break;
  448.       case 5:    n0 &= n1;        break;
  449.       case 6:    n0 |= n1;        break;
  450.       case 7:    n0 =  ~n0;        break;
  451.       case 8:    n0 = (n1 > n0);        break;
  452.       case 9:    n0 = (n1 < n0);        break;
  453.       case 10:    n0 = (n0 == n1);    break;
  454.       case 11:    n0 = !n0;        break;
  455.       case 12:    n1=n0;            break;
  456.       case 13:    t=n0; n0=n1; n1=t;    break;
  457.       case 14:                break;
  458.       case 15:    printf("In Commands Out\n");
  459.             for (temp=rpn; temp->str; temp++)
  460.                 printf(" %d %-10s%d\n",
  461.                 temp->parsin,temp->str,temp->parsout);
  462.             break;
  463.       default:    n0=Atol(av[i]);
  464.             if (IoErr()) {
  465.                 fprintf(stderr, "Bad RPN cmd: %s\n",av[i]);
  466.                 return 20;
  467.                 }
  468.             break;
  469.       }
  470.     stack[sp]=n0;
  471.     stack[sp+1]=n1;
  472.     sp += rpn[j].parsout;
  473.     }
  474. if (ifflag) return (int)(stack[sp-1]);    /* called from if: return top value */
  475. for (i=sp-1;(int)i>=0;i--) printf("%ld\n", stack[i]); /* else print stack */
  476. return 0;
  477. }
  478.  
  479. do_path()
  480. {
  481. union {    long *lp; long ll; } l;
  482. char buf[256];
  483.  
  484. puts("Current dir");
  485. l.lp = (long *) Mycli->cli_CommandDir;
  486. while (l.ll) {
  487.     l.ll <<= 2;
  488.     PathName(l.lp[1], buf, 256L);
  489.     puts(buf);
  490.     l.ll = *l.lp;
  491.     }
  492. puts("C:");
  493. return 0;
  494. }
  495.  
  496. do_pri()
  497. {
  498. int t, pri;
  499. struct Process *proc;
  500.  
  501. t=(int)(long)FindCLI(0L);
  502. t=myatoi(av[1],0,t); if (atoierr) return 20;
  503. pri=myatoi(av[2],-128,127); if (atoierr) return 20;
  504. Forbid();
  505. proc=(t==0 ? Myprocess : FindCLI((long)t));
  506. if (proc==NULL) fprintf(stderr, "process not found\n");
  507.     else SetTaskPri(proc, (long)pri);
  508. Permit();
  509. return 0;
  510. }
  511.  
  512. do_strleft()
  513. {
  514. char buf[256];
  515. int n;
  516.  
  517. strcpy(buf,av[2]);
  518. n=myatoi(av[3],1,strlen(buf)); if (atoierr) return 20;
  519. buf[n]='\0';
  520. set_var(LEVEL_SET, av[1], buf);
  521. return 0;
  522. }
  523.  
  524. do_strright()
  525. {
  526. char buf[256];
  527. int n;
  528.  
  529. strcpy(buf, av[2]);
  530. n=myatoi(av[3],1,strlen(buf)); if (atoierr) return 20;
  531. set_var(LEVEL_SET, av[1], buf+strlen(buf)-n);
  532. return 0;
  533. }
  534.  
  535. do_strmid()
  536. {
  537. char buf[256];
  538. int n1, n2;
  539.  
  540. strcpy(buf, av[2]);
  541. n1=myatoi(av[3],1,strlen(buf))-1; if (atoierr) return 20;
  542. if (ac>4) {
  543.     n2=myatoi(av[4],1,strlen(buf)-n1); if (atoierr) return 20;
  544.     buf[n1+n2]='\0';
  545.     }
  546. set_var(LEVEL_SET, av[1], buf+n1);
  547. return 0;
  548. }
  549.  
  550. do_strlen()
  551. {
  552. char buf[16];
  553.  
  554. sprintf(buf,"%d",strlen(av[2]));
  555. set_var(LEVEL_SET, av[1], buf);
  556. return 0;
  557. }
  558.  
  559. int atoierr;
  560.  
  561. myatoi(s,min,max)
  562. char *s;
  563. {
  564. int n;
  565.  
  566. n=(int)(long)Atol(s);
  567. if (atoierr=IoErr())
  568.     ierror(s,511);
  569.     else if (n<min || n>max) {
  570.         atoierr=1;
  571.         printf("%s(%d) not in (%d,%d)\n",s,n,min,max);
  572.         }
  573. return n;
  574. }
  575.  
  576. do_fltlower()
  577. {
  578. char buf[256], *s;
  579.  
  580. while (!CHECKBREAK() && gets(buf)) {
  581.     for (s=buf; *s; s++) *s=tolower(*s);
  582.     puts(buf);
  583.     }
  584. return 0;
  585. }
  586.  
  587. do_fltupper()
  588. {
  589. char buf[256], *s;
  590.  
  591. while (!CHECKBREAK() && gets(buf)) {
  592.     for (s=buf; *s; s++) *s=toupper(*s);
  593.     puts(buf);
  594.     }
  595. return 0;
  596. }
  597.  
  598. #define RXFB_RESULT  17
  599.  
  600. static struct rexxmsg {
  601.     struct Message cm_Node;
  602.     LONG   RFU1;
  603.     LONG   RFU2;
  604.     LONG   rm_Action;
  605.     LONG   rm_Result1;
  606.     LONG   rm_Result2;
  607.     char   *cm_Args[16];
  608.     LONG   RFU7;
  609.     LONG   RFU8;
  610.     LONG   RFU9;
  611.     LONG   RFU10;
  612.     LONG   RFU11;
  613.     LONG   RFU12;
  614. } mymsg;
  615.  
  616. do_rxsend()
  617. {
  618. int i=1, resflag;
  619. char *result;
  620. struct MsgPort *port, *reply;
  621. long len;
  622.  
  623. get_opt("r", &i);
  624. resflag=options;
  625. if (!(port = FindPort(av[i++]))) { fprintf(stderr, "No port %s!\n", av[--i]); return 20; }
  626. mymsg.cm_Node.mn_Node.ln_Type = NT_MESSAGE;
  627. mymsg.cm_Node.mn_Length = sizeof(struct rexxmsg);
  628. mymsg.rm_Action = (resflag ? 1L << RXFB_RESULT : 0);
  629. if (!(reply = CreatePort(NULL, 0L))) {
  630.     fprintf(stderr, "No reply port\n");
  631.     return 20;
  632.     }
  633. mymsg.cm_Node.mn_ReplyPort = reply;
  634.  
  635. for ( ; i<ac; i++) {
  636.     mymsg.cm_Args[0] = av[i];
  637.     mymsg.rm_Result2 = 0;    /* clear out the last result. */
  638.     PutMsg(port, &mymsg.cm_Node);
  639.     WaitPort(reply);
  640.  
  641.     if (resflag) {
  642.         result=(char *)mymsg.rm_Result2;
  643.         len=*( (long *)(result-4) );
  644.         if (len<0 || len>256)
  645.             fprintf(stderr, "Risultato troppo lungo\n");
  646.         else
  647.             printf("%s\n", result);
  648.         FreeMem(result, len);
  649.         }
  650.     }
  651.  
  652. if (reply) DeletePort(reply);
  653. return 0;
  654. }
  655.  
  656. do_rxrec()
  657. {
  658. struct MsgPort *port;
  659. struct rexxmsg *msg;
  660. char *portname, *str;
  661.  
  662. if (ac > 1)
  663.     portname=av[1];
  664. else
  665.     portname="rexx_csh";
  666.  
  667. port=CreatePort(portname, 0L);
  668. if (port==NULL) {
  669.     fprintf(stderr, "Can't have MsgPort %s\n", portname);
  670.     return 20;
  671.     }
  672. for (;;) {
  673.     WaitPort(port);
  674.     while (msg=(struct rexxmsg *)GetMsg(port)) {
  675.         if ( ! Strcmp(msg->cm_Args[0], "bye")) {
  676.             ReplyMsg((struct Message *)msg);
  677.             DeletePort(port);
  678.             return 0;
  679.             }
  680.         exec_command(msg->cm_Args[0]);
  681.         if (msg->rm_Action & (1L << RXFB_RESULT)) {
  682.             str = get_var(LEVEL_SET, v_lasterr);
  683.             msg->rm_Result2=(str) ? atoi(str) : 20;
  684.             }
  685.         ReplyMsg((struct Message *)msg);
  686.         }
  687.     }
  688. }
  689.